#include <stdlib.h>
#include <string.h>
#include "../header/interface.h"
#include "../header/Jeu.h"
#include "../header/Joueur.h"
#include "../header/Callbacks.h"
#include "../header/ChargerCartes.h"
#include "../header/Objets.h"

void set_parametres_fenetre_principale(GtkWidget *FenetrePrincipale)
{
    gtk_window_set_title(GTK_WINDOW(FenetrePrincipale), "Jeu de Coinche");
    gtk_window_set_default_size(GTK_WINDOW(FenetrePrincipale), 800, 800);
    gtk_window_set_position(GTK_WINDOW(FenetrePrincipale), GTK_WIN_POS_CENTER);
    gtk_window_maximize(GTK_WINDOW (FenetrePrincipale));
    gtk_window_set_type_hint(GTK_WINDOW (FenetrePrincipale), GDK_WINDOW_TYPE_HINT_DESKTOP);
    gtk_window_set_resizable(GTK_WINDOW(FenetrePrincipale), TRUE);

    gtk_window_set_icon_from_file(GTK_WINDOW(FenetrePrincipale), "data/icone.png", NULL);
}


void demande_nom_joueur(struct sObjets *obj)
{
    GtkWidget *vbox_entry;
    GtkWidget *pEntry;
    GtkWidget *pValider;

    GtkWidget *label_demande_nom = gtk_label_new("Entrez votre nom de joueur :");
    vbox_entry = gtk_vbox_new(TRUE,0);
    pEntry = gtk_entry_new_with_max_length(25);
    pValider = gtk_button_new_with_label("Valider");

    obj->box_entry=vbox_entry;

    gtk_box_pack_start(GTK_BOX(vbox_entry), label_demande_nom, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox_entry), pEntry, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox_entry), pValider, FALSE, FALSE, 0);

    g_signal_connect(G_OBJECT(pEntry), "activate", G_CALLBACK(callback_valider_nom), obj);
    g_signal_connect(G_OBJECT(pValider), "clicked", G_CALLBACK(callback_valider_nom), obj);

    gtk_table_attach_defaults(GTK_TABLE(obj->pTable), vbox_entry, 4,6,1,2);
}


void afficher_menu_annonce(struct sObjets *obj, Joueur *joueur_precedent, Joueur *joueur_partenaire)
{
    //!Création des tableaux conteneurs
    obj->pMenu_annonce = gtk_table_new(3,2, FALSE);
    gtk_table_attach(GTK_TABLE(obj->pTable), obj->pMenu_annonce, 3,7,1,3, GTK_EXPAND, GTK_EXPAND, 0,0);


    //! Création des boîtes
    GtkWidget *hbox_annonces = gtk_hbox_new(TRUE,0);    //boîte contenant les colonnes d'annonces
    GtkWidget *vbox_annonce1 = gtk_vbox_new(TRUE,3);    //boîte contenant la première colonne d'annonces
    GtkWidget *vbox_annonce2 = gtk_vbox_new(TRUE,0);    //boîte contenant la seconde colonne d'annonces
    GtkWidget *vbox_couleur = gtk_vbox_new(TRUE,0);     //boîte contenant les boutons de choix de couleur
    GtkWidget *vbox_ecran = gtk_vbox_new(TRUE, 0);      //boîte contenant l'annonce précédente et le bouton Valider

    gtk_box_pack_start(GTK_BOX(hbox_annonces), vbox_annonce1, TRUE, TRUE,10);
    gtk_box_pack_end(GTK_BOX(hbox_annonces), vbox_annonce2, TRUE, TRUE, 10);


    //! Création du label Annonce
    gchar *parametres_txt = g_locale_to_utf8("<span face=\"Sylfaen\"foreground=\"#26221d\" size=\"xx-large\"><b>Annonce</b></span>\n", -1, NULL, NULL, NULL);
    GtkWidget *label_annonce = gtk_label_new(parametres_txt);
    gtk_label_set_use_markup(GTK_LABEL(label_annonce), TRUE);
    gtk_table_attach_defaults(GTK_TABLE(obj->pMenu_annonce), label_annonce, 0,1,0,1);

    //! BOUTONS

    //! Boutons couleur

    /*On crée le tableau qui contient les valeurs renvoyées par chacun des boutons */
    int i, j;

    obj->tab_valeur_couleur[0]=COEUR;
    obj->tab_valeur_couleur[1]=PIQUE;
    obj->tab_valeur_couleur[2]=CARREAU;
    obj->tab_valeur_couleur[3]=TREFLE;

    for(i=0;i<9;i++)
    {
        for(j=80; j<170; j=j+10)
        {
           obj->tab_valeur_annonce[i]= j;
        }
    }
    obj->tab_valeur_annonce[9]=250;  //Bouton "Capot"
    obj->tab_valeur_annonce[10]=500; //Bouton "Générale"
    obj->tab_valeur_annonce[11]=1;   //Bouton "Coincher"
    obj->tab_valeur_annonce[12]=0;  //Bouton "PASSER"


    /* Chargement des images */
    GdkPixbuf *pixbuf_couleur_annonce[4];
    pixbuf_couleur_annonce[0]=gdk_pixbuf_new_from_file("data/Coeur.png", NULL);
    pixbuf_couleur_annonce[1]=gdk_pixbuf_new_from_file("data/Pique.png", NULL);
    pixbuf_couleur_annonce[2]=gdk_pixbuf_new_from_file("data/Carreau.png", NULL);
    pixbuf_couleur_annonce[3]=gdk_pixbuf_new_from_file("data/Trefle.png", NULL);


    /* Création des boutons :
    L'image pour le bouton est créée depuis le pixbuf de la carte, puis fixée sur le bouton
    Les boutons sont affichés dans la boîte vbox_couleur */

    GtkWidget *im_couleur_annonce[4];
    for(i=0;i<4;i++)
    {
        obj->bouton_couleur[i]=gtk_toggle_button_new();
        im_couleur_annonce[i]=gtk_image_new_from_pixbuf(pixbuf_couleur_annonce[i]);
        gtk_button_set_image(GTK_BUTTON(obj->bouton_couleur[i]),im_couleur_annonce[i]);
        gtk_box_pack_start(GTK_BOX(vbox_couleur), obj->bouton_couleur[i], TRUE, TRUE, 0);
        g_signal_connect(GTK_OBJECT(obj->bouton_couleur[i]), "toggled", GTK_SIGNAL_FUNC(callback_couleur_annonce), obj);
    }
    gtk_table_attach(GTK_TABLE(obj->pMenu_annonce), vbox_couleur, 1,2,0,2, GTK_EXPAND, GTK_EXPAND, 50,0);



    //! Boutons d'annonce
    obj->bouton_annonce[0]=gtk_toggle_button_new_with_label("80");
    obj->bouton_annonce[1]=gtk_toggle_button_new_with_label("90");
    obj->bouton_annonce[2]=gtk_toggle_button_new_with_label("100");
    obj->bouton_annonce[3]=gtk_toggle_button_new_with_label("110");
    obj->bouton_annonce[4]=gtk_toggle_button_new_with_label("120");
    obj->bouton_annonce[5]=gtk_toggle_button_new_with_label("130");
    obj->bouton_annonce[6]=gtk_toggle_button_new_with_label("140");
    obj->bouton_annonce[7]=gtk_toggle_button_new_with_label("150");
    obj->bouton_annonce[8]=gtk_toggle_button_new_with_label("160");
    obj->bouton_annonce[9]=gtk_toggle_button_new_with_label("Capot");
    obj->bouton_annonce[10]=gtk_toggle_button_new_with_label("Generale");
    obj->bouton_annonce[11]=gtk_toggle_button_new_with_label("Coincher");
    obj->bouton_annonce[12]=gtk_toggle_button_new_with_label("PASSER");

    g_signal_connect(GTK_OBJECT(obj->bouton_annonce[12]), "clicked", GTK_SIGNAL_FUNC(callback_points_annonce), obj);

    for(i=0;i<12;i++)
    {
        g_signal_connect(GTK_OBJECT(obj->bouton_annonce[i]), "toggled", GTK_SIGNAL_FUNC(callback_points_annonce), obj);
    }

    for(i=0;i<6;i++)
    {
        gtk_box_pack_start(GTK_BOX (vbox_annonce1), obj->bouton_annonce[i], TRUE, TRUE, 0);
    }
    for(i=6; i<13;i++)
    {
        gtk_box_pack_start(GTK_BOX (vbox_annonce2), obj->bouton_annonce[i], TRUE, TRUE, 0);
    }

    gtk_table_attach(GTK_TABLE(obj->pMenu_annonce), hbox_annonces, 0,1,1,2, GTK_EXPAND, GTK_EXPAND, 0,0);

    //!Affichage de l'annonce précédente
    if(joueur_precedent->annonce!=NULL)
    {
        GtkWidget *label_annonce_precedente;
        char *chaine_couleur=NULL;
        char *nom_joueur_precedent = getNomJoueur(joueur_precedent);
        int pts = joueur_precedent->annonce->points;
        Couleur couleur = joueur_precedent->annonce->couleur;
        switch((int)couleur)
        {
            case 0: strcpy(chaine_couleur, "PIQUE");
            break;
            case 1: strcpy(chaine_couleur, "COEUR");
            break;
            case 2: strcpy(chaine_couleur, "CARREAU");
            break;
            case 3: strcpy(chaine_couleur, "TREFLE");
            break;
        }

        gchar *annonce_precedente = g_strdup_printf("Annonce de %s : %d %s", nom_joueur_precedent, pts, chaine_couleur);
        gtk_label_set_text(GTK_LABEL(label_annonce_precedente), annonce_precedente);
        gtk_box_pack_start(GTK_BOX(vbox_ecran), label_annonce_precedente, TRUE, TRUE, 0);
    }

    //!Affichage de l'annonce du partenaire
    if(joueur_partenaire->annonce != NULL) /* A MODIFIER !! Créer une fonction booléeen AnnonceEstNulle*/
    {
        GtkWidget *label_annonce_partenaire;
        char *chaine_couleur=NULL;
        char *nom_partenaire = getNomJoueur(joueur_partenaire);
        int pts = joueur_partenaire->annonce->points;
        Couleur couleur = joueur_partenaire->annonce->couleur;
        switch((int)couleur)
        {
            case 0: strcpy(chaine_couleur, "PIQUE");
            break;
            case 1: strcpy(chaine_couleur, "COEUR");
            break;
            case 2: strcpy(chaine_couleur, "CARREAU");
            break;
            case 3: strcpy(chaine_couleur, "TREFLE");
            break;
        }

        gchar *annonce_partenaire = g_strdup_printf("Annonce de %s : %d %s", nom_partenaire, pts, chaine_couleur);
        gtk_label_set_text(GTK_LABEL(label_annonce_partenaire), annonce_partenaire);

        gtk_box_pack_start(GTK_BOX(vbox_ecran), label_annonce_partenaire, TRUE, TRUE, 0);
    }

    //!Affichage du bouton Valider

    GtkWidget *pValider = gtk_button_new_with_label("Valider");
    gtk_box_pack_end(GTK_BOX(vbox_ecran), pValider, TRUE, TRUE, 5);
    gtk_table_attach(GTK_TABLE(obj->pMenu_annonce), vbox_ecran, 0,2, 2,3, GTK_EXPAND, GTK_EXPAND, 0,20);
    g_signal_connect(GTK_OBJECT(pValider), "clicked", GTK_SIGNAL_FUNC(callback_valider_annonce), obj);
}

void detruire_menu_annonce(struct sObjets *obj)
{
    gtk_widget_destroy(obj->pMenu_annonce);
}

void afficher_annonce_en_cours(struct sObjets *obj, Joueur *joueur_en_cours/*, Joueur *joueur_humain*/)
{
    GtkWidget *label=gtk_label_new(NULL);
    GtkWidget *vbox_ecran_label_annonce = gtk_vbox_new(TRUE,0);
    GtkWidget *bouton_ok = gtk_button_new_with_label("OK");

    /*Copie la boîte écran dans la structure*/
    obj->ecran_label_annonce=vbox_ecran_label_annonce;

    /*Récupère le label de l'annonce en cours */
    char *chaine_couleur=NULL;
    char *nom = getNomJoueur(joueur_en_cours);
    int pts = joueur_en_cours->annonce->points;
    Couleur couleur = joueur_en_cours->annonce->couleur;

    switch(couleur)
    {
        case 0: strcpy(chaine_couleur, "PIQUE");
        break;
        case 1: strcpy(chaine_couleur, "COEUR");
        break;
        case 2: strcpy(chaine_couleur, "CARREAU");
        break;
        case 3: strcpy(chaine_couleur, "TREFLE");
        break;
    }

    gchar *annonce_en_cours = g_strdup_printf("Annonce de %s : %d %s", nom, pts, chaine_couleur);
    gtk_label_set_text(GTK_LABEL(label), annonce_en_cours);

    // Affichage de l'annonce en cours
    gtk_box_pack_start(GTK_BOX(vbox_ecran_label_annonce), label, TRUE, TRUE, 0);

    /*-------------------------------------------*/
    /* OPTION NON IMPLEMENTEE PAR L'IA           */

    /* Si le dernier joueur à annoncer n'est pas le partenaire du joueur humain, on affiche un bouton "coincher"*/
    /*if(joueur_en_cours->partenaire->nom != joueur_humain->nom)
    {
        GtkWidget *bouton_coincher = gtk_button_new_with_label("Coincher");
        gtk_box_pack_start(GTK_BOX(vbox_ecran_label_annonce), bouton_coincher, TRUE, TRUE, 20);
        //g_signal_connect(GTK_OBJECT(bouton_coincher), "clicked", GTK_SIGNAL_FUNC(callback_coincher), NULL);
    }*/
    /*---------------------------------------------*/

    gtk_box_pack_end(GTK_BOX(vbox_ecran_label_annonce), bouton_ok, TRUE, TRUE, 0);
    g_signal_connect(GTK_OBJECT(bouton_ok), "clicked", GTK_SIGNAL_FUNC(callback_valider_annonce_ia), obj);

    gtk_table_attach(GTK_TABLE(obj->pTable), vbox_ecran_label_annonce, 3,7, 1,2, GTK_EXPAND, GTK_EXPAND, 0,0);
}


void affiche_label_annonce_coinchee(struct sObjets *obj, Joueur *joueur_en_cours)
{
    GtkWidget *vbox_ecran = gtk_vbox_new(TRUE,0);
    GtkWidget *label_coinchee =gtk_label_new(NULL);
    GtkWidget *bouton_ok = gtk_button_new_with_label("OK");

    obj->ecran_label_annonce=vbox_ecran;

    char *nom = getNomJoueur(joueur_en_cours);
    gchar *texte = g_strdup_printf("%s a coinche votre annonce !", nom);
    gtk_label_set_text(GTK_LABEL(label_coinchee), texte);

    gtk_box_pack_start(GTK_BOX(obj->ecran_label_annonce), label_coinchee, TRUE, TRUE, 0);
    gtk_box_pack_end(GTK_BOX(obj->ecran_label_annonce), bouton_ok, TRUE, TRUE, 0);
    g_signal_connect(GTK_OBJECT(bouton_ok), "clicked", GTK_SIGNAL_FUNC(callback_valider_annonce_ia), obj);

    gtk_table_attach(GTK_TABLE(obj->pTable), obj->ecran_label_annonce, 3,7, 1,2, GTK_EXPAND, GTK_EXPAND, 0,0);
}


void affiche_label_annonce_passer(struct sObjets *obj, Joueur *joueur_en_cours)
{
    GtkWidget *vbox_ecran = gtk_vbox_new(TRUE,0);
    GtkWidget *label_passer =gtk_label_new(NULL);
    GtkWidget *bouton_ok = gtk_button_new_with_label("OK");

    obj->ecran_label_annonce=vbox_ecran;

    char *nom = getNomJoueur(joueur_en_cours);
    gchar *texte = g_strdup_printf("%s passe...", nom);
    gtk_label_set_text(GTK_LABEL(label_passer), texte);

    gtk_box_pack_start(GTK_BOX(obj->ecran_label_annonce), label_passer, TRUE, TRUE, 0);
    gtk_box_pack_end(GTK_BOX(obj->ecran_label_annonce), bouton_ok, TRUE, TRUE, 0);
    g_signal_connect(GTK_OBJECT(bouton_ok), "clicked", GTK_SIGNAL_FUNC(callback_valider_annonce_ia), obj);

    gtk_table_attach(GTK_TABLE(obj->pTable), obj->ecran_label_annonce, 3,7, 1,2, GTK_EXPAND, GTK_EXPAND, 0,0);
}


void detruire_label_annonce(struct sObjets *obj)
{
    gtk_widget_destroy(obj->ecran_label_annonce);
}


void ramasser_cartes_tapis(struct sObjets *obj)
{
    gtk_widget_destroy(obj->tapis);
}


void reinitialiser_main_joueur_ia(struct sObjets *obj, Joueur *joueur)
{
    Placement place=getPlacementJoueur(joueur);
    switch(place)
    {
        case OUEST : gtk_widget_destroy(obj->boite_main_gauche); break;
        case NORD : gtk_widget_destroy(obj->boite_main_face); break;
        case EST : gtk_widget_destroy(obj->boite_main_droite); break;
    }
}


/*void afficher_score_finaux(struct sObjets *obj, Equipe *equipe)
{

}*/

void tourAnnonce_graphique(struct sObjets *obj,
                           struct sJoueur* joueur_nord, struct sJoueur* joueur_ouest,
                           struct sJoueur* joueur_sud, struct sJoueur* joueur_est)
{
    int compteur_pass = -1;
    Annonce meilleure_annonce;
    meilleure_annonce.points = 0;
    meilleure_annonce.couleur = PIQUE;
    meilleure_annonce.coinchee = 0;
    Joueur joueur_actif;
    initJoueur(&joueur_actif);

    booleen annonce_cliquee = 0;

    if (getDealerJoueur(joueur_nord) == 1)
    {
        joueur_actif = *joueur_nord;
    }

    if (getDealerJoueur(joueur_sud) == 1)
    {
        joueur_actif = *joueur_sud;
    }

    if (getDealerJoueur(joueur_est) == 1)
    {
        joueur_actif = *joueur_est;
    }

    if (getDealerJoueur(joueur_ouest) == 1)
    {
        joueur_actif = *joueur_ouest;
    }

    while(compteur_pass < 3)
    {
        if (joueur_actif.placement == SUD)
        {
            afficher_menu_annonce(obj, joueur_ouest, joueur_nord);
            while(obj->statut != ANNONCE_VALIDEE && !annonce_cliquee)
            {
                if(obj->statut==ANNONCE_VALIDEE)
                {
                   joueur_actif.annonce->points = obj->clic_points_annonces;//pour "PASSER", on a clic_points_annonces=0;
                   joueur_actif.annonce->couleur = obj->clic_couleur_annoncee;
                   joueur_actif.annonce->coinchee = obj->clic_coinche_annoncee;
                   annonce_cliquee = 1;
                }
            }
            detruire_menu_annonce(obj);
        }
        else
        {
            if (compteur_pass != 1 && meilleure_annonce.points != 0) /* Pour pas qu'un joueur puisse coincher son partenaire ou coincher une annonce nulle */
            {
                coincher(&joueur_actif, &meilleure_annonce);
            }

            if (joueur_actif.annonce->coinchee != 1) /* Pour pas que un joueur ne parte alors qu'il a coinché juste avant */
            {
                calculAnnonce(&joueur_actif);
            }
        }

        if (joueur_actif.annonce->points > meilleure_annonce.points)
        {
            meilleure_annonce.points = joueur_actif.annonce->points;
            meilleure_annonce.couleur = joueur_actif.annonce->couleur;
            compteur_pass = 0;

            afficher_annonce_en_cours(obj, &joueur_actif);
            while(obj->statut != CLIC)
            {

            }
            detruire_label_annonce(obj);
            obj->statut = NO_CLIC;
        }
        else
        {
            if (joueur_actif.annonce->coinchee == 1)
            {
                compteur_pass = 3;
                joueur_actif.annonce->points = meilleure_annonce.points;
                joueur_actif.annonce->couleur = meilleure_annonce.couleur;
                affiche_label_annonce_coinchee(obj, &joueur_actif);
                while(obj->statut != CLIC)
                {

                }
                detruire_label_annonce(obj);
                obj->statut = NO_CLIC;
            }
            else
            {
                compteur_pass++;
                affiche_label_annonce_passer(obj, &joueur_actif);
                while(obj->statut != CLIC)
                {

                }
                detruire_label_annonce(obj);
                obj->statut = NO_CLIC;
            }
        }

        if(joueur_actif.annonce->coinchee != 1)
        {
            switch(joueur_actif.placement)
            {
                case 0 :    joueur_nord->annonce = joueur_actif.annonce;
                            joueur_actif = *joueur_ouest;
                            break;

                case 1 :    joueur_ouest->annonce = joueur_actif.annonce;
                            joueur_actif = *joueur_sud;
                            break;

                case 2 :    joueur_sud->annonce = joueur_actif.annonce;
                            joueur_actif = *joueur_est;
                            break;

                case 3 :    joueur_est->annonce = joueur_actif.annonce;
                            joueur_actif = *joueur_nord;
                            break;
            }
        }
    }

    if (0 != joueur_actif.placement)
    {
        joueur_nord->annonce->points = 0;
    }

    if (1 != joueur_actif.placement)
    {
        joueur_ouest->annonce->points = 0;
    }

    if (2 != joueur_actif.placement)
    {
        joueur_sud->annonce->points = 0;
    }

    if (3 != joueur_actif.placement)
    {
        joueur_est->annonce->points = 0;
    }

}

void faireManche_graphique(struct sObjets *obj, struct sJoueur* joueur_nord, struct sJoueur* joueur_ouest, struct sJoueur* joueur_sud,
                 struct sJoueur* joueur_est, Jeu* pli_en_cours, Jeu* tableau_de_pli)
{
    Joueur joueur_actif;
    initJoueur(&joueur_actif);
    int numero_pli, numero_carte_pli, i;
    Annonce annonce_finale;
    tourAnnonce_graphique(obj, joueur_nord, joueur_ouest, joueur_sud, joueur_est);

    if (joueur_nord->annonce->points != 0)
    {
        annonce_finale = *joueur_nord->annonce;
    }
    if (joueur_ouest->annonce->points != 0)
    {
        annonce_finale = *joueur_ouest->annonce;
    }
    if (joueur_sud->annonce->points != 0)
    {
        annonce_finale = *joueur_sud->annonce;
    }
    if (joueur_est->annonce->points != 0)
    {
        annonce_finale = *joueur_est->annonce;
    }

    for(i = 0; i < 8; i++)
    {
        if(joueur_nord->jeuMain->jeu[i].couleur == annonce_finale.couleur)
        {
            joueur_nord->jeuMain->jeu[i].atout = 1;
        }
        else
        {
            joueur_nord->jeuMain->jeu[i].atout = 0;
        }

        if(joueur_ouest->jeuMain->jeu[i].couleur == annonce_finale.couleur)
        {
            joueur_ouest->jeuMain->jeu[i].atout = 1;
        }
        else
        {
            joueur_ouest->jeuMain->jeu[i].atout = 0;
        }

        if(joueur_sud->jeuMain->jeu[i].couleur == annonce_finale.couleur)
        {
            joueur_sud->jeuMain->jeu[i].atout = 1;
        }
        else
        {
            joueur_sud->jeuMain->jeu[i].atout = 0;
        }

        if(joueur_est->jeuMain->jeu[i].couleur == annonce_finale.couleur)
        {
            joueur_est->jeuMain->jeu[i].atout = 1;
        }
        else
        {
            joueur_est->jeuMain->jeu[i].atout = 0;
        }
    }

    if (getDealerJoueur(joueur_nord) == 1)
    {
        joueur_actif = *joueur_nord;
    }

    if (getDealerJoueur(joueur_sud) == 1)
    {
        joueur_actif = *joueur_sud;
    }

    if (getDealerJoueur(joueur_est) == 1)
    {
        joueur_actif = *joueur_est;
    }

    if (getDealerJoueur(joueur_ouest) == 1)
    {
        joueur_actif = *joueur_ouest;
    }

    for(numero_pli = 0; numero_pli < 8; numero_pli++)
    {
        for(numero_carte_pli = 0; numero_carte_pli < 4; numero_carte_pli++)
        {
            jouerCarte_graphique(obj, &joueur_actif, pli_en_cours, numero_carte_pli);
            tableau_de_pli->jeu[numero_carte_pli + numero_pli * 4] = pli_en_cours->jeu[numero_carte_pli];
            switch(joueur_actif.placement)
            {
                case 0 : joueur_actif = *joueur_ouest;
                            break;

                case 1 : joueur_actif = *joueur_sud;
                            break;

                case 2 : joueur_actif = *joueur_est;
                            break;

                case 3 : joueur_actif = *joueur_nord;
                            break;
            }
        }

        remporterPli(&joueur_actif, joueur_nord, joueur_ouest, joueur_sud, joueur_est, pli_en_cours);
    }
}

void jouerCarte_graphique(struct sObjets *obj, Joueur* joueur, Jeu* pli, int numero_carte_dans_pli)
{
    int num_carte_a_jouer;
    while(obj->statut != CLIC)
    {
        obj->numero_carte_jouee; //! A MODIFIER
    }

    int i;
    /*booleen interdit = 1;
    while (interdit)
    {
        printf("Entrez le numero de la carte a jouer pour %s (de 0 a 7)", joueur->nom);
        scanf("%d",&num_carte_a_jouer);
        if ((num_carte_a_jouer < 8) && (num_carte_a_jouer >= 0))
        {
            interdit = jouerInterdit(joueur, pli, numero_carte_dans_pli, num_carte_a_jouer);
        }
        interdit = 0;
        if (interdit)
        {
            printf("Carte injouable ou mauvais numero de carte. Recommencez.\n");
        }
    }*/

    pli->jeu[numero_carte_dans_pli] = joueur->jeuMain->jeu[num_carte_a_jouer];

    joueur->jeuMain->taille--;

    poserCarte(joueur, num_carte_a_jouer, obj);

}

